
# line 2 "ANASIN.y"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <float.h>
#define CONSTANTESTRING 257
#define CONSTANTEINT 258
#define PUNTOYCOMA 259
#define DOSPUNTOS 260
#define COMA 261
#define INICORCHETE 262
#define FINCORCHETE 263
#define INIPARENTESIS 264
#define FINPARENTESIS 265
#define INILLAVE 266
#define FINLLAVE 267
#define COMILLA 268
#define CADENA 269
#define AND 270
#define OR 271
#define NEGACION 272
#define MAYOR 273
#define MAYORIGUAL 274
#define MENOR 275
#define MENORIGUAL 276
#define IGUALIGUAL 277
#define DISTINTO 278
#define SUMA 279
#define MULTIPLICACION 280
#define DIVISION 281
#define RESTA 282
#define IGUAL 283
#define VARIABLE 284
#define DEFINE 285
#define ENDDEFINE 286
#define REAL 287
#define ENTERO 288
#define STRING 289
#define WHILE 290
#define ENDWHILE 291
#define IF 292
#define ENDIF 293
#define PRINT 294
#define RENAME 295
#define ROUND 296
#define TRUNC 297
#define MAIN 298
#define ENDMAIN 299
#define CONSTANTEFLOAT 300
#define CONSTANTEBASE2 301
#define CONSTANTEBASE16 302
#ifndef YYSTYPE
#define YYSTYPE int
#endif
YYSTYPE yylval, yyval;
#define YYERRCODE 256

# line 306 "ANASIN.y"

/****************** Constantes *****************/
#define CANTIDAD_PALABRAS_RESERVADAS 15
#define CANTIDAD_MAX_TS	1000
#define ESTADO_INICIAL 0
#define ESTADO_FINAL 36
#define LARGO_MAX_TOKEN 35
#define LARGO_MAX_TOKEN_EXT 45
#define TAM_MAX_TOKENS 5000
#define TAM_MAX_CADENA 30
#define TAM_MAX_VAR 20
#define TRUE 1
#define FALSE 0
#define FLOAT_MAX_VALUE 65536 //16 BITS
#define REAL_MAX_VALUE FLT_MAX

/****************** Nros de columna para matriz de estados *****************/
#define COLUMNA_LETRA				 0
#define COLUMNA_DIGITO			 	 1
#define COLUMNA_SIMBOLO			 	 2
#define COLUMNA_PUNTO			 	 3
#define COLUMNA_DIVISION		 	 4
#define COLUMNA_NEGACION		 	 5
#define COLUMNA_COMILLAS		 	 6
#define COLUMNA_AND		       		 7
#define COLUMNA_OR		       	 	 8
#define COLUMNA_MENOR			 	 9
#define COLUMNA_MAYOR			 	 10
#define COLUMNA_IGUAL			 	 11
#define COLUMNA_SUMA			     12
#define COLUMNA_RESTA			 	 13
#define COLUMNA_MULTIPLICACION 	 	 14
#define COLUMNA_PUNTO_Y_COMA  	     15
#define COLUMNA_COMA			     16
#define COLUMNA_INI_BLOQUE		 	 17
#define COLUMNA_FIN_BLOQUE		 	 18
#define COLUMNA_INI_CORCHETE		 19
#define COLUMNA_FIN_CORCHETE		 20
#define COLUMNA_INI_PARENTESIS	 	 21
#define COLUMNA_FIN_PARENTESIS	 	 22
#define COLUMNA_DOS_PUNTOS 	 	 	 23
#define COLUMNA_BLANCO		 	 	 24

/****************** Rutinas semanticas *****************/
void iniVar();
void contVar();
void finVar();
void iniCteNum();
void contCteNum();
void finCteNum();
void iniCteString();
void contCteString();
void finCteString();
void error();
void opDivision();
void opNegacion();
void iniAnd();
void finAnd();
void iniOr();
void finOr();
void opMenor();
void opMayor();
void opIgual();
void opSuma();
void opResta();
void opMultiplicacion();
void puntoComa();
void coma();
void iniBloque();
void finBloque();
void iniCorchete();
void finCorchete();
void iniParentesis();
void finParentesis();
void nada();
void opMenorIgual();
void opMayorIgual();
void opDistinto();
void iniComent();
void contComent();
void posFinComent();
void finComent();
void posIniComent2();
void iniComent2();
void contComent2();
void posFinComent2();
void finComent2();
void puntoYComa();
void dosPuntos();
void opIgualIgual();
void finAnd();
void iniOr();
void finOr();
void iniCteOtra();
void contCteOtraValor();
void sepCteOtra();
void contCteOtraBase();
void finCteOtraBase2();
void finCteOtraBase16();

/****************** Funciones generica *****************/
void completarToken(int, int);
void analizarLexico(char *);
int inicializacion(char *);
FILE* abrirArchivo(char*, char);
int perteneceALaLista(char*, char);
void inicializarCadena();
void imprimirTablaSimbolos();
void imprimirTokens();
void convertirToken(int, char*, char*);

/****************** Funciones semanticas *****************/
int yylex(void); //Llamado por yyparse
int yyerror(char *);
int yyparse(void); //Prototipo de yyparse
int getToken(void); //Parsea cada nuevo token. Devuelve el tipo de token reconocido (Antiguo yylex)
int getEvent(char); //Toma un caracter y devuelve el numero de columna de las matrices
int yylexCont = 0; //Contador de llamadas a yylex

/****************** Funciones Yacc *****************/
//Funciones para YACC
void declararVariable(int); 	 	//Marca una VARIABLE como declarada
void setearTipoVar(int, char *); 	//Setea el tipo de las VARIABLES en la TS
void esVarDeclarada(int); 	 	   	//Verifica si la VARIABLE esta declarada
void coincidenTipos(int, int); 		//Verifica si coinciden los tipos de 2 VARIABLES
char * getStringErrorToken(int); 	//Obtiene el token esperado a partir del token pasado por parametro
void inicializarTipos(int, int); //Inicializa variables
void limpiarTipos();

//Funciones para Tercetos
int crearTerceto(char *, char *, char *);


/****************** Estructuras *****************/
struct strTablaSimbolos {
	char nombre[LARGO_MAX_TOKEN_EXT];
	char tipo[20];
	char valor[30];
	int longitud;
	char rename[LARGO_MAX_TOKEN_EXT];
	int declarada;
};

struct strTokens {
	int tipo;
	char valor[LARGO_MAX_TOKEN];
	int yylval;
    int nroLinea;
};
struct strPalabrasReservadas {
	char palabra[LARGO_MAX_TOKEN_EXT];
	int numero;
};

/****************** Variables Globales *****************/
char cadena[TAM_MAX_CADENA];
FILE *fuente;
struct strTablaSimbolos tablaSimbolos[CANTIDAD_MAX_TS];
struct strTokens listaTokens[TAM_MAX_TOKENS];
struct strPalabrasReservadas reservadas[CANTIDAD_PALABRAS_RESERVADAS];
char caracterLeido;
int tipoToken;
int yylval;
int cantCaracteres;
char tokenGenerado[LARGO_MAX_TOKEN];
int cantTokens;
int leido;
int cantComentariosAbiertos;
int posUltimoSimbolo;
int lineaLeida = 1;
char generando[TAM_MAX_CADENA];
int tokenAnterior; //Es el token que se recibio antes del actual (utilizado en manejo de error)
int tokenActual; //Es el token actual (utilizado en manejo de error)

int contadorTercetos = 0; //variables globales para generar tercetos
int eIndice = -1;
int aIndice = -1;
int tIndice = -1;
int fIndice = -1;
FILE *salidaTercetos;


int columna = 0;
/* Vactor que almacenara el tipo de variable declarada
   0 = nada
   1 = Real
   2 = Entero
   3 = String
   estas seran posicionales.
*/
int tiposVariables[10] = {0,0,0,0,0,0,0,0,0,0};
int cantVariablesDeclaradas = 0;
int syntaxLeido = 0;

/****************** Arrays Globales *****************/
char letras[] = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',
		'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
		'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
		'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '\0' };
char digitos[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '\0' };
char simbolos[] = { '@', '#', '%', '$', '?', '~', '^', '\0' };
char blancos[] = { '\n', '\t', '\r', ' ', EOF, '\0' };

/***************** MATRICES *****************/
int nuevoEstado[37][26] = {
		{ 1, 2, 36, 3, 6, 34, 10, 12, 14, 16, 19, 21, 23, 24, 25, 26, 27, 28,
				29, 30, 31, 32, 33, 35, 0 }, //0
		{ 1, 1, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36 },
		{ 36, 2, 36, 3, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36 },
		{ 36, 3, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36 },
		{ 5, 5, 5, 5, 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
				5, 5 },
		{ 5, 5, 5, 5, 7, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
				5, 5 }, //5
		{ 36, 36, 36, 36, 36, 5, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36 },
		{ 5, 5, 5, 5, 7, 8, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
				5, 5 },
		{ 8, 8, 8, 8, 8, 9, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
				8, 8 },
		{ 8, 8, 8, 8, 5, 9, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
				8, 8 },
		{ 10, 10, 10, 10, 10, 10, 11, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
				10, 10, 10, 10, 10, 10, 10, 10 }, //10
		{ 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36 },
		{ 36, 36, 36, 36, 36, 36, 36, 13, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36 },
		{ 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36 },
		{ 36, 36, 36, 36, 36, 36, 36, 36, 15, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36 },
		{ 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36 }, //15
		{ 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 17, 18, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36 },
		{ 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36 },
		{ 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36 },
		{ 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 20, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36 },
		{ 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36 }, //20
		{ 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 22, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36 }, { 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36 },
		{ 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36 },
		{ 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36 },
		{ 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36 }, //25
		{ 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36 }, { 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36 }, { 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36 },
		{ 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36 },
		{ 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36 }, //30
		{ 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36 }, { 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36 }, { 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36 }, { 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36 },
		{ 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
				36, 36, 36, 36, 36, 36, 36, 36 }, //35
		{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
				0, 0 } };

void (*proceso[37][26])()= {
	{	iniVar,iniCteNum,error,iniCteNum,opDivision,opNegacion,iniCteString,iniAnd,iniOr,opMenor,opMayor,opIgual,opSuma,opResta,opMultiplicacion,puntoYComa,coma,iniBloque,finBloque,iniCorchete,finCorchete,iniParentesis,finParentesis,dosPuntos,nada},
	{	contVar,contVar,finVar,finVar,finVar,finVar,finVar,finVar,finVar,finVar,finVar,finVar,finVar,finVar,finVar,finVar,finVar,finVar,finVar,finVar,finVar,finVar,finVar,finVar,finVar,finVar}, //2
	{	finCteNum,contCteNum,finCteNum,contCteNum,finCteNum,finCteNum,finCteNum,finCteNum,finCteNum,finCteNum,finCteNum,finCteNum,finCteNum,finCteNum,finCteNum,finCteNum,finCteNum,finCteNum,finCteNum,finCteNum,finCteNum,finCteNum,finCteNum,finCteNum,finCteNum}, //3
	{	finCteNum,contCteNum,finCteNum,finCteNum,finCteNum,finCteNum,finCteNum,finCteNum,finCteNum,finCteNum,finCteNum,finCteNum,finCteNum,finCteNum,finCteNum,finCteNum,finCteNum,finCteNum,finCteNum,finCteNum,finCteNum,finCteNum,finCteNum,finCteNum,finCteNum}, //4
	{	contComent,contComent,contComent,contComent,finComent,contComent,contComent,contComent,contComent,contComent,contComent,contComent,contComent,contComent,contComent,contComent,contComent,contComent,contComent,contComent,contComent,contComent,contComent,contComent,contComent}, //5
	{	contComent,contComent,contComent,contComent,posIniComent2,posFinComent,contComent,contComent,contComent,contComent,contComent,contComent,contComent,contComent,contComent,contComent,contComent,contComent,contComent,contComent,contComent,contComent,contComent,contComent,contComent},
	{	nada,nada,nada,nada,nada,iniComent,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada},
	{	contComent,contComent,contComent,contComent,posIniComent2,iniComent2,contComent,contComent,contComent,contComent,contComent,contComent,contComent,contComent,contComent,contComent,contComent,contComent,contComent,contComent,contComent,contComent,contComent,contComent,contComent},
	{	contComent2,contComent2,contComent2,contComent2,contComent2,posFinComent2,contComent2,contComent2,contComent2,contComent2,contComent2,contComent2,contComent2,contComent2,contComent2,contComent2,contComent2,contComent2,contComent2,contComent2,contComent2,contComent2,contComent2,contComent2,contComent2},
	{	contComent2,contComent2,contComent2,contComent2,finComent2,posFinComent2,contComent2,contComent2,contComent2,contComent2,contComent2,contComent2,contComent2,contComent2,contComent2,contComent2,contComent2,contComent2,contComent2,contComent2,contComent2,contComent2,contComent2,contComent2,contComent2}, //10
	{	contCteString,contCteString,contCteString,contCteString,contCteString,contCteString,contCteString,contCteString,contCteString,contCteString,contCteString,contCteString,contCteString,contCteString,contCteString,contCteString,contCteString,contCteString,contCteString,contCteString,contCteString,contCteString,contCteString,contCteString,contCteString},
	{	finCteString,finCteString,finCteString,finCteString,finCteString,finCteString,finCteString,finCteString,finCteString,finCteString,finCteString,finCteString,finCteString,finCteString,finCteString,finCteString,finCteString,finCteString,finCteString,finCteString,finCteString,finCteString,finCteString,finCteString,finCteString},
	{	error,error,error,error,error,error,error,finAnd,error,error,error,error,error,error,error,error,error,error,error,error,error,error,error,error,error},
	{	nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada},
	{	error,error,error,error,error,error,error,error,finOr,error,error,error,error,error,error,error,error,error,error,error,error,error,error,error,error},
	{	nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada}, //15
	{	nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,opDistinto,opMenorIgual,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada},
	{	nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada},
	{	nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada},
	{	nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,opMayorIgual,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada},
	{	nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada}, //20
	{	nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,opIgualIgual,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada},
	{	nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada},
	{	nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada},
	{	nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada},
	{	nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada}, //25
	{	nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada},
	{	nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada},
	{	nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada},
	{	nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada},
	{	nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada}, //30
	{	nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada},
	{	nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada},
	{	nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada},
	{	nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada},
	{	nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada}, //35
	{	nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada,nada}
};


/***************** PROGRAMA *****************/
int main(int argc, char *argv[]) {
	char nombreArchivo[200] = "Entrada.txt";
	int result;

	//Llamada al AL
	analizarLexico(nombreArchivo);
	//Llamada al AS
	result = yyparse();

	if(result == 0) {
    	//Imprimo por pantalla y a un archivo la TS
    	imprimirTablaSimbolos();
		//cerramos el archivo de tercetos
		fclose(salidaTercetos);
    }

	
	return EXIT_SUCCESS;
}

//En el lexico, yylex iba parseando un token por vez.
//Ahora los tokens los parsea en su totalidad analizarLexico , y luego yylex los ira entregando de a uno al ser invocada.
int yylex(void) {
	int tipoToken;

   if (yylexCont > cantTokens) {
   		return EXIT_SUCCESS;
   }

	// Recorre la lista de tokens obtenidos por analizarLexico.
	yylval = listaTokens[yylexCont].yylval;
	tipoToken = listaTokens[yylexCont].tipo;
	tokenAnterior = tokenActual;
	tokenActual = tipoToken;

	//Llevo la cuenta de las lineas que voy leyendo.
	if(listaTokens[yylexCont].nroLinea > 0) {
		lineaLeida = listaTokens[yylexCont].nroLinea;
	}

	// Se incrementa el contador de llamados a yylex.
  	yylexCont++;
  	return(tipoToken);
}

//Esta funcion es la que analizara los tokens y cargara la listaTokens.
void analizarLexico(char* nombreArchivo) {

	if(inicializacion(nombreArchivo) == 1 ) {
     	 exit(printf("ERROR: No se pudo abrir el archivo fuente.\n"));
   }

   while(!feof(fuente)){
		if(leido == FALSE) {
      	caracterLeido = (char)getc(fuente);
         // suma las lineas del archivo ingresado
			if (caracterLeido == '\n') {
				lineaLeida++;
			}
		}
		// Carga el tipo de Token invocando a la funcion getToken.
		listaTokens[cantTokens].tipo = getToken();
		if (listaTokens[cantTokens].tipo != 0)
		{
			//Carga el valor del Token
     	  	strcpy(listaTokens[cantTokens].valor, tokenGenerado);
     		//Carga el codigo de Token
    		listaTokens[cantTokens].yylval = yylval;
     		//Carga la linea del archivo donde esta el token
			listaTokens[cantTokens].nroLinea = lineaLeida;
  	  		//Se incrementa el contador de tokens
     	  	cantTokens++;
		}
	}
  	fclose(fuente);
}

//Inicializa la lista de palabras reservadas y los contadores.
int inicializacion(char * nombreArchivo) {

	if ((fuente = abrirArchivo(nombreArchivo, 'L')) == NULL) {
		return EXIT_FAILURE;
	}

	// Inicializa la lista de palabras reservadas
	strcpy(reservadas[0].palabra, "DEFINE");
	reservadas[0].numero = DEFINE;
	strcpy(reservadas[1].palabra, "ENDDEFINE");
	reservadas[1].numero = ENDDEFINE;
	strcpy(reservadas[2].palabra, "REAL");
	reservadas[2].numero = REAL;
	strcpy(reservadas[3].palabra, "ENTERO");
	reservadas[3].numero = ENTERO;
	strcpy(reservadas[4].palabra, "STRING");
	reservadas[4].numero = STRING;
	strcpy(reservadas[5].palabra, "WHILE");
	reservadas[5].numero = WHILE;
	strcpy(reservadas[6].palabra, "ENDWHILE");
	reservadas[6].numero = ENDWHILE;
	strcpy(reservadas[7].palabra, "IF");
	reservadas[7].numero = IF;
	strcpy(reservadas[8].palabra, "ENDIF");
	reservadas[8].numero = ENDIF;
	strcpy(reservadas[9].palabra, "PRINT");
	reservadas[9].numero = PRINT;
	strcpy(reservadas[10].palabra, "RENAME");
	reservadas[10].numero = RENAME;
	strcpy(reservadas[11].palabra, "ROUND");
	reservadas[11].numero = ROUND;
	strcpy(reservadas[12].palabra, "TRUNC");
	reservadas[12].numero = TRUNC;
	strcpy(reservadas[13].palabra, "MAIN");
	reservadas[13].numero = MAIN;
	strcpy(reservadas[14].palabra, "ENDMAIN");
	reservadas[14].numero = ENDMAIN;

	cantTokens = 0;
	cantCaracteres = 0;
	cantComentariosAbiertos = 0;
	posUltimoSimbolo = 0;
	inicializarCadena();

	return EXIT_SUCCESS;
}

FILE* abrirArchivo(char* nombreArchivo, char modo) {
	if (modo == 'L') {
		return (fopen(nombreArchivo, "r"));
	}
	return (fopen(nombreArchivo, "w"));
}

//Inicializa la cadena en su totalidad con \0.
void inicializarCadena() {
	int i;
	for (i = 0; i < TAM_MAX_CADENA; i++) {
		cadena[i] = '\0';
		generando[i] = '\0';
	}
}

//Este seria el yylex del analizador lexico.
int getToken() {
    //Inicializo variables por cada nuevo token
	int estado = ESTADO_INICIAL;
	int columna = -1;
	yylval = -1;
	tipoToken = 0;
	leido = FALSE;

	while (!feof(fuente) && estado != ESTADO_FINAL) {
		columna = getEvent(caracterLeido);

      (proceso[estado][columna])();
		estado = nuevoEstado[estado][columna];

    	if(leido == FALSE) {
      	caracterLeido = (char)getc(fuente);
         // suma las lineas del archivo ingresado
			if (caracterLeido == '\n') {
				lineaLeida++;
			}
     	}
	}

	if(feof(fuente)) {
		columna = getEvent(caracterLeido);
		(proceso[estado][columna])();
		estado = nuevoEstado[estado][columna];
       //Verifica si los comentarios se encuentran correctamnete cerrados
       if(cantComentariosAbiertos > 0) {
			error();
		}
	}

	return tipoToken;
}

//Devuelve el nro de columna segun el tipo de caracter leido.
int getEvent(char caracterLeido) {

	if (perteneceALaLista(letras, caracterLeido)) {
		// printf("COLUMNA_LETRA\n");
		return (COLUMNA_LETRA);
	} else if (perteneceALaLista(digitos, caracterLeido)) {
		//printf("COLUMNA_DIGITO\n");
		return (COLUMNA_DIGITO);
	} else if (perteneceALaLista(simbolos, caracterLeido)) {
		//printf("COLUMNA_SIMBOLO\n");
		return (COLUMNA_SIMBOLO);
	} else if (perteneceALaLista(blancos, caracterLeido)) {
		//printf("COLUMNA_BLANCO\n");
		return (COLUMNA_BLANCO);
	}

	//Resto de los caracteres
	switch (caracterLeido) {
	case '+': { //printf("COLUMNA_SUMA\n");
		return (COLUMNA_SUMA);
	}
	case '-': { //printf("COLUMNA_RESTA\n");
		return (COLUMNA_RESTA);
	}
	case '*': { //printf("COLUMNA_MULTIPLICACION\n");
		return (COLUMNA_MULTIPLICACION);
	}
	case '/': { //printf("COLUMNA_DIVISION\n");
		return (COLUMNA_DIVISION);
	}
	case ';': { //printf("COLUMNA_PUNTO_Y_COMA\n");
		return (COLUMNA_PUNTO_Y_COMA);
	}
	case ',': { //printf("COLUMNA_COMA\n");
		return (COLUMNA_COMA);
	}
	case '.': { //printf("COLUMNA_PUNTO\n");
		return (COLUMNA_PUNTO);
	}
	case '"': { //printf("COLUMNA_COMILLAS\n");
		return (COLUMNA_COMILLAS);
	}
	case '>': { //printf("COLUMNA_MAYOR\n");
		return (COLUMNA_MAYOR);
	}
	case '<': { //printf("COLUMNA_MENOR\n");
		return (COLUMNA_MENOR);
	}
	case '=': { //printf("COLUMNA_IGUAL\n");
		return (COLUMNA_IGUAL);
	}
	case '(': { //printf("COLUMNA_INI_PARENTESIS\n");
		return (COLUMNA_INI_PARENTESIS);
	}
	case ')': { //printf("COLUMNA_FIN_PARENTESIS\n");
		return (COLUMNA_FIN_PARENTESIS);
	}
	case '{': { //printf("COLUMNA_INI_BLOQUE\n");
		return (COLUMNA_INI_BLOQUE);
	}
	case '}': { //printf("COLUMNA_FIN_BLOQUE\n");
		return (COLUMNA_FIN_BLOQUE);
	}
	case '[': { //printf("COLUMNA_INI_CORCHETE\n");
		return (COLUMNA_INI_CORCHETE);
	}
	case ']': { //printf("COLUMNA_FIN_CORCHETE\n");
		return (COLUMNA_FIN_CORCHETE);
	}
	case ':': { //printf("COLUMNA_DOS_PUNTOS\n");
		return (COLUMNA_DOS_PUNTOS);
	}
	case '!': { //printf("COLUMNA_NEGACION\n");
		return (COLUMNA_NEGACION);
	}
	case '&': { //printf("COLUMNA_AND\n");
		return (COLUMNA_AND);
	}
	case '|': { //printf("COLUMNA_OR\n");
		return (COLUMNA_OR);
	}
	}

	//Caracter no admitido por el lenguaje. Cortar Proceso.
	exit(printf("ERROR ANALEX: Caracter '%c' no permitido.", caracterLeido));
}

int perteneceALaLista(char* lista, char caracterLeido) {
	int i;
	for (i = 0; lista[i] != '\0'; i++) {
		if (lista[i] == caracterLeido) {
			return 1;
		}
	}
	return 0;
}

int esPalabraReservada(char *c) {
	int i;
	for (i = 0; i < CANTIDAD_PALABRAS_RESERVADAS; i++) {
		// Compara las palabras, IMPLEMENTAR CASE SENSITIVE
		if (strcmp(reservadas[i].palabra, c) == 0) {
			return reservadas[i].numero;
		}
	}
	return FALSE;
}

//Ya no la usamamos mas.
void imprimirTokens() {
	FILE *fileTokens;
	char tokenFormateado[LARGO_MAX_TOKEN_EXT];
	int i, j = 0;
	//Abrir archivo para guardar la lista de tokens
	if ((fileTokens = abrirArchivo("ListaTokens.txt", 'E')) == NULL) {
		printf("ERROR: No se pudo abrir el archivo de salida de tokens.\n");
	}
	printf("Lista de Tokens\n\n");
	for (i = 0; i < cantTokens; i++) {
		convertirToken(listaTokens[i].tipo, listaTokens[i].valor,
				tokenFormateado);
		if (i == cantTokens - 1) {
			//Ultimo token
			printf("%-10d %s\n", i + 1, tokenFormateado);
			fprintf(fileTokens, "%-10d %s\n", i + 1, tokenFormateado); // Guardar en archivo
		} else {
			printf("%-10d %s\n", i + 1, tokenFormateado); //Pantalla
			fprintf(fileTokens, "%-10d %s\n", i + 1, tokenFormateado); // Guardar en archivo
		}
		if (j == 19) {
			j = 0;
			printf("Presione una tecla para continuar...\n");

		}
		j++;
	}
	fclose(fileTokens);
}

void imprimirTablaSimbolos() {
	FILE *fileSimbolos;
	int i;

	//Abrir archivo para guardar la tabla de simbolos
	if ((fileSimbolos = abrirArchivo("TablaSimbolos.txt", 'E')) == NULL) {
		printf(
				"ERROR: No se pudo abrir el archivo de salida de la tabla de simbolos.\n");
	}
	//Imprime la tabla de simbolos y guarda en archivo de salida
	printf("\n\nTabla de Simbolos\n");
	printf("%s%33s%20s%18s%18s\n", "Nombre", "Tipo", "Valor", "Longitud", "Rename");
	printf(
			"--------------------------------------------------------------------------------------------------------\n");
	fprintf(fileSimbolos, "%s%33s%20s%18s%18s\n", "Nombre", "Tipo", "Valor", "Longitud", "Rename");
	fprintf(
			fileSimbolos,
			"--------------------------------------------------------------------------------------------------------\n");
	for (i = 0; i < posUltimoSimbolo; i++) {
		if (tablaSimbolos[i].longitud > 0) {
			printf("%-35.33s%-19.17s%-15.13s%-15.0d%-35.33s\n", tablaSimbolos[i].nombre,
					tablaSimbolos[i].tipo, "-", tablaSimbolos[i].longitud,
					tablaSimbolos[i].rename);
			fprintf(fileSimbolos, "%-35.33s%-19.17s%-15.13s%-15.0d%-35.33s\n",
					tablaSimbolos[i].nombre, tablaSimbolos[i].tipo, "-",
					tablaSimbolos[i].longitud, tablaSimbolos[i].rename);
		} else {
			printf("%-35.33s%-19.17s%-15.13s%-15s%-35.33s\n", tablaSimbolos[i].nombre,
					tablaSimbolos[i].tipo, tablaSimbolos[i].valor, "-",
					tablaSimbolos[i].rename);
			fprintf(fileSimbolos, "%-35.33s%-19.17s%-15.13s%-15s%-35.33s\n",
					tablaSimbolos[i].nombre, tablaSimbolos[i].tipo,
					tablaSimbolos[i].valor, "-", tablaSimbolos[i].rename);
		}
	}
	fclose(fileSimbolos);
}

int buscarTS(char *simbolo) {
	int i;
	for (i = 0; i < posUltimoSimbolo; i++) {
		if (strcmp(tablaSimbolos[i].nombre, simbolo) == 0) {
			return (i);
		}
	}
	return (-1);
}


int agregarTS(struct strTablaSimbolos simbolo) {

	//Se comprueba que el simbolo no exista
	if ((yylval = buscarTS(simbolo.nombre)) != -1) {
		return yylval; //Ya existe, no se agrega
	}
	//Se marca como no declarada
	simbolo.declarada = 0;
	//Se agrega a la tabla
	tablaSimbolos[posUltimoSimbolo] = simbolo;
	//Se guarda la posicion donde se agrego
	yylval = posUltimoSimbolo;
	//Se incrementa el contador de simbolos
	posUltimoSimbolo++;
	return (posUltimoSimbolo - 1);
}

void convertirToken(int tipoToken, char *valor, char *salida) {
	int i;
	//Inicializa la salida
	for (i = 0; i < LARGO_MAX_TOKEN_EXT; i++) {
		salida[i] = '\0';
	}
	salida[0] = '<';
	salida[1] = ' ';
	if (tipoToken == VARIABLE) {
		//Variable
		strcat(salida, "ID:");
		strcat(salida, valor);
	} else {
		if (DEFINE <= tipoToken && ENDMAIN >= tipoToken) {
			//Palabra reservada
			strcat(salida, "RSV:");
			strcat(salida, valor);
		} else {
			if (tipoToken == CONSTANTEBASE2) {
				//Palabra reservada
				strcat(salida, "CTE_BASE_2:");
				strcat(salida, valor);
			} else {
				if (tipoToken == CONSTANTEBASE16) {
					//Palabra reservada
					strcat(salida, "CTE_BASE_16:");
					strcat(salida, valor);
				} else {
					//Otro
					strcat(salida, valor);
				}
			}
		}
	}
	strcat(salida, " >");
}

/****************** Funciones Yacc *****************/
int yyerror(char *cMsg) {
	int i;
	printf("\n Token Actual: %d.", tokenActual );
	printf("\n Token Anterior: %d.", tokenAnterior );
	printf("\n*** %s ***.\nLinea: %d. ", cMsg , lineaLeida);
	printf("No se esperaba %s luego de %s.\n", getStringErrorToken(tokenActual), getStringErrorToken(tokenAnterior));
	printf("--> ");
	for(i = 0; i < cantTokens; i++) {
	if(listaTokens[i].nroLinea == lineaLeida)
		printf("%s ", listaTokens[i].valor);
	}
	printf("\n\n");
}

char * getStringErrorToken(int numeroToken) {
	switch(numeroToken) {
		case DEFINE: return "la palabra reservada DEFINE";
		case ENDDEFINE: return "la palabra reservada ENDDEFINE";
		case WHILE: return "la palabra reservada WHILE";
		case ENDWHILE: return "la palabra reservada ENDWHILE";
		case IF: return "la palabra reservada IF";
		case ENDIF: return "la palabra reservada ENDIF";
		case PRINT: return "la palabra reservada PRINT";
		case ROUND: return "la palabra reservada ROUND";
		case TRUNC: return "la palabra reservada TRUNC";
		case RENAME: return "la palabra reservada RENAME";
		case MAIN: return "la palabra reservada MAIN";
		case ENDMAIN: return "la palabra reservada ENDMAIN";
		case CONSTANTEINT: return "la Constante Entera";
		case CONSTANTEFLOAT: return "la Constante Real";
		case CONSTANTESTRING: return "la Constante String";
		case VARIABLE: return "la VARIABLE";
		case ENTERO: return "un ENTERO";
		case REAL: return "un REAL";
		case STRING: return "un STRING";
		case INILLAVE: return "'{'";
		case FINLLAVE: return "'}'";
		case INICORCHETE: return "'['";
		case FINCORCHETE: return "']'";
		case INIPARENTESIS: return "'('";
		case FINPARENTESIS: return "')'";
		case COMA: return "','";
		case PUNTOYCOMA: return "';'";
		case MULTIPLICACION: return "'*'";
		case DIVISION: return "'/'";
		case SUMA: return "'+'";
		case RESTA: return "'-'";
		case IGUAL: return "'='";
		case IGUALIGUAL: return "'=='";
		case MAYOR: return "'>'";
		case MENOR: return "'<'";
		case MAYORIGUAL: return "'>='";
		case MENORIGUAL: return "'<='";
		case DISTINTO: return "'<>'";
		case NEGACION: return "'!'";
		case AND: return "'&&'";
		case OR: return "'||'";
	}
}

void declararVariable(int posVar) {
	if (posVar > -1) {
		// Se marca la variable como declarada
		tablaSimbolos[posVar].declarada++;
	}

	if (tablaSimbolos[posVar].declarada > 1) {
		// La variable ya estaba declarada
		exit(printf("\nSYNTAX ERROR. Variable %s previamente declarada. Linea: %d.\n", tablaSimbolos[posVar].nombre, lineaLeida));
	}
}

//Recorre las variables y les asigna el tipo
void setearTipoVar(int tipo, char *descripcion) {
	int i;
	// Recorre las variables declaradas y aun sin tipo de la tabla de simbolos
 	for (i = 0; i < posUltimoSimbolo; i++) {
 		if (tablaSimbolos[i].tipo == 0  && tablaSimbolos[i].declarada == 1) {
 		//	tablaSimbolos[i].tipo = tipo;
 		//	strcpy(tablaSimbolos[i].tipo, descripcion);
 		}
	}
}

//Comprueba que las variables esten declaradas.
void esVarDeclarada(int posVar) {
	if (tablaSimbolos[posVar].declarada == 0) {
		// Variable no declarada
		exit(printf("\nSYNTAX ERROR. Variable %s no declarada. Linea: %d\n", tablaSimbolos[posVar].nombre, lineaLeida));
	}
}





void coincidenTipos(int pos1, int pos2) {
	//int tipo1 = tablaSimbolos[pos1].tipo;
	//int tipo2 = tablaSimbolos[pos2].tipo;
	/*if (tipo1 != tipo2) {
	  	if((tipo1 == REAL && tipo2 != CTE_NUM) || (tipo2 == REAL && tipo1 != CTE_NUM)) {
			// Distintos tipos de variable
			exit(printf("\nSYNTAX ERROR. No coinciden los tipos entre %s y %s. Linea: %d.\n", tablaSimbolos[pos1].nombre, tablaSimbolos[pos2].nombre, ultimaLineaLeida));
		}  */
}

void iniVar() {
	//  printf(" \n iniVar,");
	cantCaracteres = 1;
	inicializarCadena();
	strcpy(generando, "Variable o Palabra Reservada");
	cadena[cantCaracteres - 1] = caracterLeido;
}

void contVar() {
	//  printf(" contVar,");
	cantCaracteres++;
	cadena[cantCaracteres - 1] = caracterLeido;
}

void finVar() {
	//  printf("finVar \n");
	struct strTablaSimbolos simbolo;

	leido = TRUE; //Indica que no debe leerse otro caracter

	//Se verifica si es una palabra reservada
	if ((tipoToken = esPalabraReservada(cadena)) != 0) {
		strcpy(tokenGenerado, cadena);
		return; //Se vuelve, no hay que agregar a la TS
	}

	tipoToken = VARIABLE;

	// printf("token: %s\n", cadena);
	if (cantCaracteres > TAM_MAX_VAR) {
		exit(
				printf(
						"\nERROR ANALEX: La variable '%s' excede la cantidad maxima de caracteres permitidos(%d).\n",
						cadena, TAM_MAX_VAR));
	}
	strcpy(tokenGenerado, cadena);
	//Agregar a TS
	strcpy(simbolo.nombre, tokenGenerado);
	strcpy(simbolo.tipo, "ID");
	strcpy(simbolo.valor, "");
	simbolo.longitud = 0;
	strcpy(simbolo.rename, "-");
	agregarTS(simbolo);
}

void iniCteNum() {
	// printf("\n iniCteNum,");
	cantCaracteres = 1;
	inicializarCadena();
	strcpy(generando, "Constante Numerica");
	cadena[cantCaracteres - 1] = caracterLeido;
}

void contCteNum() {
	//printf(" iniCteNum,");
	cantCaracteres++;
	if (cantCaracteres == TAM_MAX_CADENA) {
		printf(
				"ERROR ANALEX: El valor '%s' esta fuera del rango numerico permitido(%d). \n",
				cadena, TAM_MAX_VAR);
		//
		exit(1);
	}
	cadena[cantCaracteres - 1] = caracterLeido;
}

void finCteNum() {
	//printf("f inCteNum\n");
	//Manjo todas las constantes numericas como float
	float valor;
	char** pointer = NULL;
	struct strTablaSimbolos simbolo;
	int i;
	leido = TRUE; //Indica que no debe leerse otro caracter

	strcpy(tokenGenerado, cadena);

	//Convierto la cadena a float
	valor = strtod(cadena, pointer);
	if (valor < 0) {
		valor *= -1;
	}

	//Verificar si se esta fuera del rango del float
	if (valor > FLOAT_MAX_VALUE) { // FLT_MAX
		printf("\nANALEX ERROR: El valor '%s' esta fuera del rango numerico permitido (%d). Linea %d.\n",
								cadena, FLOAT_MAX_VALUE, lineaLeida);
		
		exit(1);
	}

	for (i = 0; tokenGenerado[i] != '\0'; i++) {
		if (tokenGenerado[i] == '.') {
			tipoToken = CONSTANTEFLOAT;
			strcpy(simbolo.tipo, "CONSTANTE_FLOAT");
			break;
		} else {
			tipoToken = CONSTANTEINT;
			strcpy(simbolo.tipo, "CONSTANTE_INT");
		}
	}

	strcpy(tokenGenerado, cadena);

	//Agregar a TS
	strcpy(simbolo.nombre, tokenGenerado);
	strcpy(simbolo.valor, tokenGenerado);
	simbolo.longitud = 0;
	strcpy(simbolo.rename, "-");
	agregarTS(simbolo);
}

void iniCteString() {
	//printf("\n iniCteString,");
	cantCaracteres = 1;
	inicializarCadena();
	strcpy(generando, "Constante String");
	cadena[cantCaracteres - 1] = caracterLeido;
}

void contCteString() {
	//printf(" contCteString,");
	cantCaracteres++;

	if (cantCaracteres == TAM_MAX_CADENA) {
		printf(
				"ERROR ANALEX: La constante '%s' excede la cantidad maxima de caracteres permitidos para un string (%d).\n",
				cadena, TAM_MAX_CADENA);
		//
		exit(1);
	}
	cadena[cantCaracteres - 1] = caracterLeido;
}

void finCteString() {
	//printf("finCteString\n");
	struct strTablaSimbolos simbolo;
	tipoToken = CONSTANTESTRING;
	strcpy(tokenGenerado, cadena);

	//Agregar a TS
	strcpy(simbolo.nombre, tokenGenerado);
	strcpy(simbolo.tipo, "CONSTANTE_STRING");
	strcpy(simbolo.valor, tokenGenerado);
	simbolo.longitud = cantCaracteres - 2; // no cuento las dos doble comillas
	strcpy(simbolo.rename, "-");
	agregarTS(simbolo);
	leido = TRUE; //Indica que no debe leerse otro caracter
}

void opSuma() {
	//printf("opSuma\n");
	completarToken(1, SUMA);
}

void opResta() {
	//printf("opResta\n");
	completarToken(1, RESTA);
}

void opMultiplicacion() {
	//printf("opMultiplicacion\n");
	completarToken(1, MULTIPLICACION);
}

void opDivision() {
	//printf("opDivision\n");
	completarToken(1, DIVISION);
}

void iniBloque() {
	//printf("iniBloque\n");
	completarToken(1, INILLAVE);
}

void finBloque() {
	//printf("finBloque\n");
	completarToken(1, FINLLAVE);
}

void iniCorchete() {
	//printf("iniCorchete\n");
	completarToken(1, INICORCHETE);
}

void finCorchete() {
	//printf("finCorchete\n");
	completarToken(1, FINCORCHETE);
}

void coma() {
	//printf("coma\n");
	completarToken(1, COMA);
}

void dosPuntos() {
	//printf("dosPuntos\n");
	completarToken(1, DOSPUNTOS);
}

void opNegacion() {
	//printf("opNegacion\n");
	completarToken(1, NEGACION);
}

void opIgual() {
	// printf("opIgual\n");
	completarToken(1, IGUAL);
}

void opMayor() {
	//printf("opMayor\n");
	completarToken(1, MAYOR);
}

void opMenor() {
	//printf("opMenor\n");
	completarToken(1, MENOR);
}

void igualIgual() {
	// printf("igualIgual\n");
	completarToken(2, IGUALIGUAL);
}

void opMayorIgual() {
	// printf("opMayorIgual\n");
	completarToken(2, MAYORIGUAL);
}

void opMenorIgual() {
	//printf("opMenorIgual\n");
	completarToken(2, MENORIGUAL);
}

void opDistinto() {
	//printf("opDistinto\n");
	completarToken(2, DISTINTO);
}

void puntoYComa() {
	//	printf("puntoYComa\n");
	completarToken(1, PUNTOYCOMA);
}

void opIgualIgual() {
	//printf("opIgualIgual\n");
	completarToken(2, IGUALIGUAL);
}

void iniAnd() {
	//printf("iniAnd\n");
	completarToken(1, AND);
	strcpy(generando, "Operador AND");
}

void finAnd() {
	//printf("finAnd\n");
	completarToken(2, AND);
}

void iniOr() {
	//printf("iniOr\n");
	completarToken(1, OR);
	strcpy(generando, "Operador OR");
}

void finOr() {

	// printf("finOr\n");

	completarToken(2, OR);

}

void completarToken(int cantCarac, int tipo) {
	// printf("completarToken\n");
	tipoToken = tipo;
	if (cantCarac == 1) {
		inicializarCadena();
	}
	cantCaracteres = cantCarac;

	cadena[cantCaracteres - 1] = caracterLeido;
	strcpy(tokenGenerado, cadena);
}

void nada() {
	//printf("nada, ");
	if (leido == TRUE) {
		leido = FALSE;
	} else {
		leido = TRUE;
	}
}

void error() {
	//	printf("error\n");
	if (strcmp(generando, "") != 0) {
		exit(
				printf("ERROR ANALEX: Generando %s, Linea %d\n.", generando,
						lineaLeida));
	} else {
		exit(printf("ERROR ANALEX: Linea: %d , Caracter: %c\n", lineaLeida, caracterLeido));
	}
}

void iniComent() {
	//printf("iniComent\n");
	tipoToken = 0; //Limpio el tipoToken seteado por opDiv
	strcpy(generando, "Comentario Simple");
	cantComentariosAbiertos++; //Se abre un bloque

	if (cantComentariosAbiertos > 1) {
		exit(printf("ERROR ANALEX: Error al crear comentario.\n"));
	}
}

void contComent() {
	//printf("contComent\n");
	//Nada
}

void posFinComent() {
	// printf("posFinComent\n");
	//Nada
}

void finComent() {
	//printf("finComent\n");
	cantComentariosAbiertos--; //Se cierra un bloque

	if (cantComentariosAbiertos > 0) {
		exit(printf("ERROR ANALEX: Error al crear comentario.\n"));
	}
}

void posIniComent2() {
	//printf("posIniComent2\n");
	//Nada
}

void iniComent2() {
	// printf("iniComent2\n");
	cantComentariosAbiertos++; //Se abre un bloque
	strcpy(generando, "Comentario Anidado");
	if (cantComentariosAbiertos > 2) {
		exit(
				printf(
						"ERROR ANALEX: Error al crear comentario de segundo nivel.\n"));
	}
}

void contComent2() {
	//printf("contComent2\n");
	//Nada
}

void posFinComent2() {
	//printf("posFinComent2\n");
	//Nada
}

void finComent2() {
	//printf("finComent2\n");
	cantComentariosAbiertos--; //Se cierra un bloque

	if (cantComentariosAbiertos > 1) {
		exit(
				printf(
						"ERROR ANALEX: Error al crear comentario de segundo nivel.\n"));
	}
}

void inicializarTipos( int columna, int tipo){
   tiposVariables[columna] = tipo;
}

void limpiarTipos(){
   int a;
   for(a = 0; a<10 ;a++)
   	tiposVariables[a] = 0;
}

void iniParentesis() {

	//Guardo el parentesis que ya tengo parseado.
	char caracterLeidoAnterior = caracterLeido;
	int i = 0;
	char cadenaTemp[TAM_MAX_CADENA];
	//En este punto empieza el reconocimiento de una posible constante en otra base.
	//Leo el siguiente caracter.
	caracterLeido = (char) getc(fuente);

	//Si leo un espacio en blanco entonces solamente debo parsear el parentesis.	
	if (caracterLeido == ' ') { //Vuelvo el cursos un caracter hacia atras.
		ungetc(caracterLeido, fuente);
		caracterLeido = caracterLeidoAnterior;
		completarToken(1, INIPARENTESIS);

	} else { //En  este momento tenemos parseado un "INIPARENTESIS" y el siguiente caracter no es un espacio, por lo que consideramos
			 //que sea un posible inicio de constante en otra base.

		//Almaceno en una cadena temporal los caracteres que voy parseando.
		cantCaracteres = 2;
		cadenaTemp[0] = '('; // Agrego el parentesis como primer caracter.
		cadenaTemp[cantCaracteres - 1] = caracterLeido; //Agrego luego el caracter leido.

		//Empiezo a evaluar que tipo de token estoy parseando.
		//Leo el siguiente caracter.
		caracterLeido = (char) getc(fuente);
		while ((perteneceALaLista(letras, caracterLeido))
				|| (perteneceALaLista(digitos, caracterLeido))) {
			cantCaracteres++;
			cadenaTemp[cantCaracteres - 1] = caracterLeido;
			caracterLeido = (char) getc(fuente);
		}

		cadenaTemp[cantCaracteres] = caracterLeido;

		//Si despues de la variable leo una coma, estoy en una constante en otra base, es el unico token valido.
		if (caracterLeido == ',') {

			inicializarCadena();
			strcpy(generando, "Constante en otra base.");
			for (i = 0; i <= cantCaracteres; i++)
				cadena[i] = cadenaTemp[i];

			caracterLeido = (char) getc(fuente);
			cantCaracteres++;
			contCteOtraBase();

		} else {
			//Si no es coma, no tengo una constante en otra base, por lo que hago el unget y tengo que reconocer solo el iniparentesis.
			for (i = cantCaracteres; i > 0; i--)
				ungetc(cadenaTemp[i], fuente);
			//Reconozco un INI_PARENTESIS, cargo el valor de caracter leido y vuelvo al estado inicial.	
			caracterLeido = cadenaTemp[0];
			completarToken(1, INIPARENTESIS);

		}

	}
}

//Esta funcion no la invoco mediante el automata, la invoco desde iniParentesis cuando reconozco constante en otra base.
void iniCteOtra() {
	//Llegado este punto, ya se que lo que estoy por parsear es una constante en otra base.
	//Tengo que inicializar la cadena y agregar el INI_PARENTESIS como primer caracter.
	printf("valor leido %c", caracterLeido);

	//Inicializo la cadena y copio el INI_PARENTESIS al inicio de la misma.
	inicializarCadena();
	strcpy(generando, "Constante en otra base.");
	cantCaracteres = 1;
	cadena[cantCaracteres - 1] = '(';

}

void contCteOtraValor() {

	printf("contCteOtraValor\n");

	//printf("\nleido %c",caracterLeido);
	cantCaracteres++;
	cadena[cantCaracteres - 1] = caracterLeido;
}

void sepCteOtra() {
	printf("sepCteOtra\n");
	printf("\nleido %c", caracterLeido);
	cantCaracteres++;
	cadena[cantCaracteres - 1] = caracterLeido;
}

void contCteOtraBase() {
	printf("contConstOtraValor\n");

	//printf("\nleido %d",caracterLeido);

	//En este metodo esta la logica que diferencia una constante en binario o hexa.
	if (caracterLeido == '2') {
		printf("Binario\n");
		cantCaracteres++;
		cadena[cantCaracteres - 1] = caracterLeido;

		caracterLeido = (char) getc(fuente);
		finCteOtraBase2();
	} else {
		if (caracterLeido == '1') { //Almaceno el uno en la cadena.
			cantCaracteres++;
			cadena[cantCaracteres - 1] = caracterLeido;
			//Leo el otro caracter que tiene que ser un 6, sino error.
			caracterLeido = (char) getc(fuente);
			if (caracterLeido == '6') {
				cantCaracteres++;
				cadena[cantCaracteres - 1] = caracterLeido;

				caracterLeido = (char) getc(fuente);
				finCteOtraBase16();
			} else {
				error();
			}
		} else {
			error();
		}
	}
}

void finCteOtraBase2() {
	struct strTablaSimbolos simbolo;
	//printf("finConstOtra\n");
	//printf("\nleido %c",caracterLeido);
	cantCaracteres++;
	cadena[cantCaracteres - 1] = caracterLeido;
	tipoToken = CONSTANTEBASE2;
	completarToken(cantCaracteres, CONSTANTEBASE2);
	strcpy(tokenGenerado, cadena);

	//Agregar a TS
	strcpy(simbolo.nombre, tokenGenerado);
	strcpy(simbolo.tipo, "CONSTANTE_BASE_2");
	strcpy(simbolo.valor, tokenGenerado);
	simbolo.longitud = 0;
	strcpy(simbolo.rename, "-");
	agregarTS(simbolo);
	leido = FALSE; //Indica que no debe leerse otro caracter
}

void finCteOtraBase16() {
	struct strTablaSimbolos simbolo;
	//printf("finConstOtra\n");
	//printf("\nleido %c",caracterLeido);
	cantCaracteres++;
	cadena[cantCaracteres - 1] = caracterLeido;
	tipoToken = CONSTANTEBASE16;
	completarToken(cantCaracteres, CONSTANTEBASE16);
	strcpy(tokenGenerado, cadena);

	//Agregar a TS
	strcpy(simbolo.nombre, tokenGenerado);
	strcpy(simbolo.tipo, "CONSTANTE_BASE_16");
	strcpy(simbolo.valor, tokenGenerado);
	simbolo.longitud = 0;
	strcpy(simbolo.rename, "-");
	agregarTS(simbolo);
	leido = FALSE; //Indica que no debe leerse otro caracter
}

void finParentesis() {
	// printf("finParentesis\n");
	completarToken(1, FINPARENTESIS);
}

int crearTerceto(char * op1, char *op2, char *op3) {
	
	//abro el archivo al comienzo de la creacion de los tercetos
	if(contadorTercetos == 0){
		//Abrir archivo para guardar los tercetos
		if ((salidaTercetos = abrirArchivo("Tercetos.txt", 'E')) == NULL) {
			printf(
					"ERROR: No se pudo abrir el archivo de salida de tercetos.\n");
		}
	}
	
	contadorTercetos++;
	printf("\n ** Creando Terceto %d : ",contadorTercetos);
	printf("(%s | %s | %s)\n",op1,op2,op3);
	
	//guardamos el terceto en el archivo de salida
	fprintf(salidaTercetos, "%d (%s | %s | %s)\n",contadorTercetos,op1,op2,op3);
	
	return contadorTercetos;
}











FILE *yytfilep;
char *yytfilen;
int yytflag = 0;
int svdprd[2];
char svdnams[2][2];

int yyexca[] = {
  -1, 1,
  0, -1,
  -2, 0,
  -1, 44,
  261, 12,
  -2, 11,
  0,
};

#define YYNPROD 67
#define YYLAST 214

int yyact[] = {
      55,      61,      67,     119,      66,      45,       4,      60,
     118,      55,      61,      26,     121,      44,      31,      49,
      60,      24,       6,      25,      26,      27,      30,      28,
      29,     109,      24,      53,      25,      68,      27,      30,
      28,      29,      75,      96,      53,      76,      64,      28,
      29,      38,     116,      62,      58,      59,      84,      85,
      28,      29,      87,     106,      62,      58,      59,      12,
      13,      14,      78,      79,      80,      81,      83,      82,
      75,      65,     104,      76,      72,      73,      75,     105,
      94,      76,      91,      90,      71,      46,      42,      41,
      75,      40,      39,      76,      37,      93,      92,      33,
     120,     115,     114,     108,     107,      57,      16,      56,
      15,      52,      51,      95,      50,      22,      43,      21,
       9,      47,      48,      77,      54,      22,      35,      21,
       3,      89,      88,      32,      57,      56,       8,     112,
     117,       3,      36,      23,      20,      19,      18,      17,
      34,       7,      16,      69,      11,      10,       5,       2,
       1,       9,       0,      63,       0,       0,       0,       0,
       0,       0,       0,       0,       0,       0,       0,       0,
      70,       0,       0,       0,      74,       0,       0,       0,
       0,      86,       0,       0,      60,       0,       0,       0,
       0,       0,       0,       0,       0,       0,      99,     100,
      47,       0,     101,      97,      98,      72,     102,     103,
       0,       0,       0,      77,       0,       0,      22,       0,
      21,     113,     111,       0,     110,       0,      76,      51,
      85,      52,      50,       0,      73,      48,       0,      22,
      35,      21,      15,      95,       0,      43,
};

int yypact[] = {
    -292,   -1000,    -267,   -1000,   -1000,    -292,    -232,    -273,
   -1000,    -272,    -232,    -173,   -1000,   -1000,   -1000,    -273,
   -1000,   -1000,   -1000,   -1000,   -1000,   -1000,   -1000,   -1000,
   -1000,    -180,    -242,    -182,    -183,    -185,    -186,   -1000,
   -1000,    -271,    -294,   -1000,    -187,    -257,    -248,    -219,
    -296,    -298,    -255,   -1000,   -1000,   -1000,    -257,    -189,
    -202,    -248,    -215,    -234,   -1000,   -1000,   -1000,   -1000,
   -1000,   -1000,   -1000,   -1000,    -248,   -1000,   -1000,    -209,
   -1000,   -1000,    -190,    -191,    -175,    -176,    -193,    -231,
    -248,    -248,   -1000,    -248,    -248,    -248,   -1000,   -1000,
   -1000,   -1000,   -1000,   -1000,    -248,    -248,    -199,   -1000,
    -194,    -214,    -167,    -168,    -259,    -271,    -231,   -1000,
    -273,   -1000,   -1000,    -234,    -234,    -245,   -1000,   -1000,
   -1000,    -169,    -170,   -1000,   -1000,    -223,   -1000,   -1000,
    -285,    -264,   -1000,   -1000,    -171,    -279,   -1000,   -1000,
   -1000,   -1000,
};

int yypgo[] = {
       0,     136,     135,     134,     112,     104,     133,     132,
     102,     131,     129,      96,     128,      94,     127,     126,
     125,     124,      95,      93,     123,     122,     105,      99,
     120,     119,     100,     114,     113,      98,      97,     108,
     106,     107,
};

int yyr1[] = {
       0,       2,       1,       1,       3,       5,       5,       6,
       7,       7,       7,       8,       9,       8,      10,      12,
       4,      11,      11,      13,      13,      13,      13,      13,
      13,      13,      21,      24,      14,      25,      15,      16,
      27,      17,      28,      17,      18,      19,      20,      26,
      26,      26,      29,      29,      29,      30,      30,      30,
      30,      30,      30,      30,      30,      23,      22,      22,
      22,      22,      32,      33,      33,      33,      33,      33,
      33,      31,      31,
};

int yyr2[] = {
       2,       0,       3,       1,       3,       1,       2,       3,
       1,       1,       1,       1,       0,       4,       0,       0,
       5,       1,       2,       1,       1,       1,       1,       1,
       1,       1,       0,       0,       8,       0,       7,       4,
       0,       6,       0,       6,       5,       5,       7,       1,
       3,       3,       1,       3,       3,       1,       1,       1,
       1,       1,       1,       1,       3,       3,       1,       3,
       3,       2,       3,       1,       1,       1,       1,       1,
       1,       1,       1,
};

int yychk[] = {
   -1000,      -1,      -2,      -4,     298,      -3,     285,     -10,
      -4,      -5,      -6,      -7,     287,     288,     289,     -11,
     -13,     -14,     -15,     -16,     -17,     -18,     -19,     -20,
     290,     292,     284,     294,     296,     297,     295,     286,
      -5,     260,     -12,     -13,     -21,     264,     283,     264,
     264,     264,     264,      -8,     284,     299,     264,     -22,
     -32,     272,     -26,     -29,     -30,     284,     -31,     257,
     -18,     -19,     301,     302,     264,     258,     300,     -26,
     257,     284,     300,     300,     284,      -9,     -22,     265,
     270,     271,     -32,     279,     282,     -33,     273,     274,
     275,     276,     278,     277,     280,     281,     -26,     259,
     -27,     -28,     265,     265,     261,     261,     265,     -23,
     266,     -32,     -32,     -29,     -29,     -26,     -30,     -30,
     265,     265,     265,     259,     259,     284,      -8,     -23,
     -25,     -11,     259,     259,     265,     -24,     293,     267,
     259,     291,
};

int yydef[] = {
       1,      -2,       0,       3,      14,       0,       0,       0,
       2,       0,       5,       0,       8,       9,      10,      15,
      17,      19,      20,      21,      22,      23,      24,      25,
      26,       0,       0,       0,       0,       0,       0,       4,
       6,       0,       0,      18,       0,       0,       0,       0,
       0,       0,       0,       7,      -2,      16,       0,       0,
      54,       0,       0,      39,      42,      45,      46,      47,
      48,      49,      50,      51,       0,      65,      66,       0,
      32,      34,       0,       0,       0,       0,       0,       0,
       0,       0,      57,       0,       0,       0,      59,      60,
      61,      62,      63,      64,       0,       0,       0,      31,
       0,       0,       0,       0,       0,       0,       0,      29,
       0,      55,      56,      40,      41,      58,      43,      44,
      52,       0,       0,      36,      37,       0,      13,      27,
       0,       0,      33,      35,       0,       0,      30,      53,
      38,      28,
};

int *yyxi;


/*****************************************************************/
/* PCYACC LALR parser driver routine -- a table driven procedure */
/* for recognizing sentences of a language defined by the        */
/* grammar that PCYACC analyzes. An LALR parsing table is then   */
/* constructed for the grammar and the skeletal parser uses the  */
/* table when performing syntactical analysis on input source    */
/* programs. The actions associated with grammar rules are       */
/* inserted into a switch statement for execution.               */
/*****************************************************************/


#ifndef YYMAXDEPTH
#define YYMAXDEPTH 200
#endif
#ifndef YYREDMAX
#define YYREDMAX 1000
#endif
#define PCYYFLAG -1000
#define WAS0ERR 0
#define WAS1ERR 1
#define WAS2ERR 2
#define WAS3ERR 3
#define yyclearin pcyytoken = -1
#define yyerrok   pcyyerrfl = 0
YYSTYPE yyv[YYMAXDEPTH];     /* value stack */
int pcyyerrct = 0;           /* error count */
int pcyyerrfl = 0;           /* error flag */
int redseq[YYREDMAX];
int redcnt = 0;
int pcyytoken = -1;          /* input token */


yyparse()
{
  int statestack[YYMAXDEPTH]; /* state stack */
  int      j, m;              /* working index */
  YYSTYPE *yypvt;
  int      tmpstate, tmptoken, *yyps, n;
  YYSTYPE *yypv;


  tmpstate = 0;
  pcyytoken = -1;
#ifdef YYDEBUG
  tmptoken = -1;
#endif
  pcyyerrct = 0;
  pcyyerrfl = 0;
  yyps = &statestack[-1];
  yypv = &yyv[-1];


  enstack:    /* push stack */
#ifdef YYDEBUG
    printf("at state %d, next token %d\n", tmpstate, tmptoken);
#endif
    if (++yyps - &statestack[YYMAXDEPTH] > 0) {
      yyerror("pcyacc internal stack overflow");
      return(1);
    }
    *yyps = tmpstate;
    ++yypv;
    *yypv = yyval;


  newstate:
    n = yypact[tmpstate];
    if (n <= PCYYFLAG) goto defaultact; /*  a simple state */


    if (pcyytoken < 0) if ((pcyytoken=yylex()) < 0) pcyytoken = 0;
    if ((n += pcyytoken) < 0 || n >= YYLAST) goto defaultact;


    if (yychk[n=yyact[n]] == pcyytoken) { /* a shift */
#ifdef YYDEBUG
      tmptoken  = pcyytoken;
#endif
      pcyytoken = -1;
      yyval = yylval;
      tmpstate = n;
      if (pcyyerrfl > 0) --pcyyerrfl;
      goto enstack;
    }


  defaultact:


    if ((n=yydef[tmpstate]) == -2) {
      if (pcyytoken < 0) if ((pcyytoken=yylex())<0) pcyytoken = 0;
      for (yyxi=yyexca; (*yyxi!= (-1)) || (yyxi[1]!=tmpstate); yyxi += 2);
      while (*(yyxi+=2) >= 0) if (*yyxi == pcyytoken) break;
      if ((n=yyxi[1]) < 0) { /* an accept action */
        if (yytflag) {
          int ti; int tj;
          yytfilep = fopen(yytfilen, "w");
          if (yytfilep == NULL) {
            fprintf(stderr, "Can't open t file: %s\n", yytfilen);
            return(0);          }
          for (ti=redcnt-1; ti>=0; ti--) {
            tj = svdprd[redseq[ti]];
            while (strcmp(svdnams[tj], "$EOP"))
              fprintf(yytfilep, "%s ", svdnams[tj++]);
            fprintf(yytfilep, "\n");
          }
          fclose(yytfilep);
        }
        return (0);
      }
    }


    if (n == 0) {        /* error situation */
      switch (pcyyerrfl) {
        case WAS0ERR:          /* an error just occurred */
          yyerror("syntax error");
          yyerrlab:
            ++pcyyerrct;
        case WAS1ERR:
        case WAS2ERR:           /* try again */
          pcyyerrfl = 3;
	   /* find a state for a legal shift action */
          while (yyps >= statestack) {
	     n = yypact[*yyps] + YYERRCODE;
	     if (n >= 0 && n < YYLAST && yychk[yyact[n]] == YYERRCODE) {
	       tmpstate = yyact[n];  /* simulate a shift of "error" */
	       goto enstack;
            }
	     n = yypact[*yyps];


	     /* the current yyps has no shift on "error", pop stack */
#ifdef YYDEBUG
            printf("error: pop state %d, recover state %d\n", *yyps, yyps[-1]);
#endif
	     --yyps;
	     --yypv;
	   }


	   yyabort:
            if (yytflag) {
              int ti; int tj;
              yytfilep = fopen(yytfilen, "w");
              if (yytfilep == NULL) {
                fprintf(stderr, "Can't open t file: %s\n", yytfilen);
                return(1);              }
              for (ti=1; ti<redcnt; ti++) {
                tj = svdprd[redseq[ti]];
                while (strcmp(svdnams[tj], "$EOP"))
                  fprintf(yytfilep, "%s ", svdnams[tj++]);
                fprintf(yytfilep, "\n");
              }
              fclose(yytfilep);
            }
	     return(1);


	 case WAS3ERR:  /* clobber input char */
#ifdef YYDEBUG
          printf("error: discard token %d\n", pcyytoken);
#endif
          if (pcyytoken == 0) goto yyabort; /* quit */
	   pcyytoken = -1;
	   goto newstate;      } /* switch */
    } /* if */


    /* reduction, given a production n */
#ifdef YYDEBUG
    printf("reduce with rule %d\n", n);
#endif
    if (yytflag && redcnt<YYREDMAX) redseq[redcnt++] = n;
    yyps -= yyr2[n];
    yypvt = yypv;
    yypv -= yyr2[n];
    yyval = yypv[1];
    m = n;
    /* find next state from goto table */
    n = yyr1[n];
    j = yypgo[n] + *yyps + 1;
    if (j>=YYLAST || yychk[ tmpstate = yyact[j] ] != -n) tmpstate = yyact[yypgo[n]];
    switch (m) { /* actions associated with grammar rules */
      
      case 1:
# line 24 "ANASIN.y"
      {printf("%d --> Inicio\n",syntaxLeido++);} break;
      case 6:
# line 34 "ANASIN.y"
      {cantVariablesDeclaradas = 0;} break;
      case 8:
# line 41 "ANASIN.y"
      {
       inicializarTipos(columna, 1);
       columna++;
      } break;
      case 9:
# line 46 "ANASIN.y"
      {
       inicializarTipos(columna, 2);
       columna++;
      } break;
      case 10:
# line 51 "ANASIN.y"
      {
       inicializarTipos(columna, 3);
       columna++;
      } break;
      case 11:
# line 58 "ANASIN.y"
      { declararVariable(yypvt[-0]);
        limpiarTipos();
        columna = 0;
        cantVariablesDeclaradas++;
      } break;
      case 12:
# line 64 "ANASIN.y"
      {
        declararVariable(yypvt[-0]);
        columna = 0;
        cantVariablesDeclaradas++;
      } break;
      case 14:
# line 73 "ANASIN.y"
      {
       printf("%d --> Inicio del Programa Principal\n",syntaxLeido++);
      } break;
      case 15:
# line 77 "ANASIN.y"
      {
       printf("%d --> Fin del Programa Principal\n",syntaxLeido++);
      } break;
      case 26:
# line 97 "ANASIN.y"
      {
       printf("%d --> Comienzo de Iteracion\n",syntaxLeido++);
      } break;
      case 27:
# line 101 "ANASIN.y"
      {
       printf("%d --> Fin de Iteracion\n",syntaxLeido++);
      } break;
      case 29:
# line 108 "ANASIN.y"
      {
       printf("%d --> Comienzo de Decision\n",syntaxLeido++);
      } break;
      case 31:
# line 115 "ANASIN.y"
      {
      	//Verifica si la variable esta declarada
      	esVarDeclarada(yypvt[-3]);
      
   	printf("%d --> Asignacion a '%s' \n",syntaxLeido++, tablaSimbolos[yypvt[-3]].nombre);
      	//Valida los tipos
      	coincidenTipos(yypvt[-3], yypvt[-1]);
      	char indiceTerceto[100];
      	sprintf(indiceTerceto,"[%i]",eIndice);
      	aIndice = crearTerceto("IGUAL",tablaSimbolos[yypvt[-3]].nombre,indiceTerceto);
      	
      } break;
      case 32:
# line 130 "ANASIN.y"
      {
         printf("%d --> Impresion \n",syntaxLeido++);
      } break;
      case 34:
# line 135 "ANASIN.y"
      {
         printf("%d --> Impresion \n",syntaxLeido++);
      } break;
      case 39:
# line 151 "ANASIN.y"
      {
      	printf("\nTerceto: expresion ---> termino");
      	eIndice = tIndice;
      } break;
      case 40:
# line 156 "ANASIN.y"
      {
      	//Valida los tipos
      	coincidenTipos(yypvt[-2], yypvt[-0]);
         	printf("%d --> Expresion SUMA \n",syntaxLeido++);
      	
         	//printf("Valores %s %s\n",tablaSimbolos[yypvt[-2]].nombre,tablaSimbolos[yypvt[-0]].nombre);
      	char indiceTercetoE[100];
      	sprintf(indiceTercetoE,"[%i]",eIndice);
      	char indiceTercetoT[100];
      	sprintf(indiceTercetoT,"[%i]",tIndice);
      	eIndice = crearTerceto("SUMA",indiceTercetoE,indiceTercetoT);
      
} break;
      case 41:
# line 170 "ANASIN.y"
      {
      	//Valida los tipos
      	coincidenTipos(yypvt[-2], yypvt[-0]);
         	printf("%d --> Expresion RESTA \n",syntaxLeido++);
      	char indiceTercetoE[100];
      	sprintf(indiceTercetoE,"[%i]",eIndice);
      	char indiceTercetoT[100];
      	sprintf(indiceTercetoT,"[%i]",tIndice);
      	eIndice = crearTerceto("RESTA",indiceTercetoE,indiceTercetoT);
      //printf("Valores %s %s\n",tablaSimbolos[yypvt[-2]].nombre,tablaSimbolos[yypvt[-0]].nombre);
      } break;
      case 42:
# line 184 "ANASIN.y"
      {
      	tIndice = fIndice;
      } break;
      case 43:
# line 188 "ANASIN.y"
      {
      	//Valida los tipos
      	coincidenTipos(yypvt[-2], yypvt[-0]);
         	printf("%d --> Termino MULTIPLICACION \n",syntaxLeido++);
      	//printf("Valores %s %s\n",tablaSimbolos[yypvt[-2]].nombre,tablaSimbolos[yypvt[-0]].nombre);
       	char indiceTercetoF[100];
      	sprintf(indiceTercetoF,"[%i]",fIndice);
      	char indiceTercetoT[100];
      	sprintf(indiceTercetoT,"[%i]",tIndice);
      	tIndice = crearTerceto("MULTIPLICACION",indiceTercetoT,indiceTercetoF);
      
} break;
      case 44:
# line 201 "ANASIN.y"
      {
      	//Valida los tipos
      	coincidenTipos(yypvt[-2], yypvt[-0]);
         	printf("%d --> Termino DIVISION \n",syntaxLeido++);
      	char indiceTercetoF[100];
      	sprintf(indiceTercetoF,"[%i]",fIndice);
      	char indiceTercetoT[100];
      	sprintf(indiceTercetoT,"[%i]",tIndice);
      	tIndice = crearTerceto("DIVISION",indiceTercetoT,indiceTercetoF);
      //printf("Valores %s %s\n",tablaSimbolos[yypvt[-2]].nombre,tablaSimbolos[yypvt[-0]].nombre);
      } break;
      case 45:
# line 215 "ANASIN.y"
      {
      	fIndice = crearTerceto(tablaSimbolos[yypvt[-0]].nombre,"---","---");
      	//Verifica si la variable esta declarada
      	esVarDeclarada(yypvt[-0]);
      } break;
      case 46:
# line 221 "ANASIN.y"
      {
      	fIndice = crearTerceto(tablaSimbolos[yypvt[-0]].nombre,"---","---");
      	//Verifica si la variable esta declarada
      } break;
      case 47:
# line 226 "ANASIN.y"
      {
      	fIndice = crearTerceto(tablaSimbolos[yypvt[-0]].nombre,"---","---");
      	//Verifica si la variable esta declarada
      } break;
      case 48:
# line 231 "ANASIN.y"
      {
      	fIndice = crearTerceto(tablaSimbolos[yypvt[-0]].nombre,"---","---");
      	//Verifica si la variable esta declarada
      } break;
      case 49:
# line 236 "ANASIN.y"
      {
      	fIndice = crearTerceto(tablaSimbolos[yypvt[-0]].nombre,"---","---");
      	//Verifica si la variable esta declarada
      } break;
      case 50:
# line 241 "ANASIN.y"
      {
      	fIndice = crearTerceto(tablaSimbolos[yypvt[-0]].nombre,"---","---");
      	//Verifica si la variable esta declarada
      } break;
      case 51:
# line 246 "ANASIN.y"
      {
      	fIndice = crearTerceto(tablaSimbolos[yypvt[-0]].nombre,"---","---");
      	//Verifica si la variable esta declarada
      } break;
      case 52:
# line 251 "ANASIN.y"
      {
      	tIndice = fIndice;
      } break;
      case 55:
# line 261 "ANASIN.y"
      {
          printf("%d --> Condicion AND \n",syntaxLeido++);
      } break;
      case 56:
# line 265 "ANASIN.y"
      {
          printf("%d --> Condicion OR \n",syntaxLeido++);
      } break;
      case 57:
# line 269 "ANASIN.y"
      {
          printf("%d --> Condicion NEGACION \n",syntaxLeido++);
      } break;
      case 59:
# line 277 "ANASIN.y"
      {
          printf("%d --> Comparador MAYOR \n",syntaxLeido++);
      } break;
      case 60:
# line 281 "ANASIN.y"
      {
          printf("%d --> Comparador MAYORIGUAL \n",syntaxLeido++);
      } break;
      case 61:
# line 285 "ANASIN.y"
      {
          printf("%d --> Comparador MENOR \n",syntaxLeido++);
      } break;
      case 62:
# line 289 "ANASIN.y"
      {
          printf("%d --> Comparador MENORIGUAL \n",syntaxLeido++);
      } break;
      case 63:
# line 293 "ANASIN.y"
      {
          printf("%d --> Comparador DISTINTO \n",syntaxLeido++);
      } break;
      case 64:
# line 297 "ANASIN.y"
      {
          printf("%d --> Comparador IGUALIGUAL \n",syntaxLeido++);
      } break;    }
    goto enstack;
}
